#include <gtest/gtest.h>
#include <chrono>
#include <thread>
#include <memory>
#include <vector>
#include <random>
#include "viml/garbage_collector.h"
#include "viml/object.h"
#include "viml/value.h"

using namespace viml;

// 模拟具体对象类，用于测试
class MockStringObject : public Object {
private:
    std::string data_;

public:
    explicit MockStringObject(const std::string& str)
        : Object(ObjectHeader::Type::STRING), data_(str) {}

    const std::string& data() const { return data_; }
    size_t size() const { return data_.length(); }

    void cleanup() override {
        do_cleanup();
    }

protected:
    void do_cleanup() override {
        // 清理资源
        data_.clear();
    }
};

class MockListObject : public Object {
private:
    std::vector<Value> elements_;

public:
    MockListObject() : Object(ObjectHeader::Type::LIST) {}
    explicit MockListObject(const std::vector<Value>& elems)
        : Object(ObjectHeader::Type::LIST), elements_(elems) {}

    size_t size() const { return elements_.size(); }
    bool empty() const { return elements_.empty(); }

    void push_back(const Value& value) {
        elements_.push_back(value);
    }

    Value get(size_t index) const {
        if (index >= elements_.size()) {
            throw std::out_of_range("Index out of range");
        }
        return elements_[index];
    }

    void cleanup() override {
        do_cleanup();
    }

protected:
    void do_cleanup() override {
        elements_.clear();
    }
};

class MockDictObject : public Object {
private:
    std::unordered_map<std::string, Value> data_;

public:
    MockDictObject() : Object(ObjectHeader::Type::DICT) {}

    size_t size() const { return data_.size(); }
    bool empty() const { return data_.empty(); }

    void set(const std::string& key, const Value& value) {
        data_[key] = value;
    }

    Value get(const std::string& key) const {
        auto it = data_.find(key);
        if (it == data_.end()) {
            return Value(); // nil值
        }
        return it->second;
    }

    bool contains(const std::string& key) const {
        return data_.find(key) != data_.end();
    }

    void cleanup() override {
        do_cleanup();
    }

protected:
    void do_cleanup() override {
        data_.clear();
    }
};

/**
 * 分代垃圾回收器测试类
 *
 * 测试覆盖范围：
 * 1. 基本GC功能 - 对象管理、根集操作、回收过程
 * 2. 分代机制 - 对象晋升、代际管理、晋升策略
 * 3. 标记-清除算法 - 标记过程、清除过程、可达性分析
 * 4. 根对象扫描 - 不同类型根对象的处理、根集完整性
 * 5. 增量垃圾回收 - 增量标记、增量清除、阶段管理
 * 6. 性能特征 - 回收效率、内存使用、并发安全
 * 7. 边界条件 - 异常情况、内存压力、大量对象
 * 8. 统计信息 - 各种统计数据的准确性和完整性
 */
class GenerationalGCTest : public ::testing::Test {
protected:
    void SetUp() override {
        gc_ = std::make_unique<GarbageCollector>();
        root_set_ = std::make_unique<GCRootSet>();
        gc_->set_root_set(root_set_.get());

        // 确保GC处于启用状态
        gc_->set_enabled(true);

        // 重置统计信息
        gc_->reset_stats();
        root_set_->reset_stats();
    }

    void TearDown() override {
        // 清理测试环境
        if (gc_) {
            gc_->reset_stats();
        }
        if (root_set_) {
            root_set_->clear_roots();
            root_set_->reset_stats();
        }
    }

    // 辅助方法：创建测试对象
    std::unique_ptr<MockStringObject> create_string(const std::string& str) {
        return std::make_unique<MockStringObject>(str);
    }

    std::unique_ptr<MockListObject> create_list(const std::vector<Value>& elems = {}) {
        return std::make_unique<MockListObject>(elems);
    }

    std::unique_ptr<MockDictObject> create_dict() {
        return std::make_unique<MockDictObject>();
    }

    // 辅助方法：创建大量对象用于压力测试
    void create_objects(size_t count) {
        for (size_t i = 0; i < count; ++i) {
            auto obj = create_string("test_string_" + std::to_string(i));
            gc_->add_object(obj.get());
            test_objects_.push_back(std::move(obj));
        }
    }

    // 辅助方法：创建复杂的对象图
    void create_object_graph() {
        // 创建一个复杂的对象引用图
        auto root_list = create_list();
        auto dict = create_dict();
        auto str1 = create_string("root_string");
        auto str2 = create_string("child_string");

        // 建立引用关系
        dict->set("key1", Value::make_number(42));  // 创建一个整数值
        root_list->push_back(Value::string("test"));  // 创建一个字符串值

        gc_->add_object(root_list.get());
        gc_->add_object(dict.get());
        gc_->add_object(str1.get());
        gc_->add_object(str2.get());

        // 添加到根集
        root_set_->add_root(root_list.get());
        root_set_->add_root(dict.get());

        graph_objects_.push_back(std::move(root_list));
        graph_objects_.push_back(std::move(dict));
        graph_objects_.push_back(std::move(str1));
        graph_objects_.push_back(std::move(str2));
    }

    // 辅助方法：测量执行时间
    template<typename Func>
    double measure_time(Func&& func) {
        auto start = std::chrono::high_resolution_clock::now();
        func();
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        return duration.count() / 1000.0; // 转换为毫秒
    }

    std::unique_ptr<GarbageCollector> gc_;
    std::unique_ptr<GCRootSet> root_set_;
    std::vector<std::unique_ptr<Object>> test_objects_;
    std::vector<std::unique_ptr<Object>> graph_objects_;
};

// ============================================================================
// 1. 基本GC功能测试
// ============================================================================

/**
 * 测试GC基本初始化和配置
 * 验证GC能够正确初始化并处于可用状态
 */
TEST_F(GenerationalGCTest, BasicInitialization) {
    EXPECT_NE(gc_, nullptr);
    EXPECT_NE(root_set_, nullptr);
    EXPECT_TRUE(gc_->is_enabled());

    // 验证初始统计信息
    auto stats = gc_->get_stats();
    EXPECT_EQ(stats.total_objects, 0);
    EXPECT_EQ(stats.total_collections, 0);
    EXPECT_EQ(stats.young_gen_objects, 0);
    EXPECT_EQ(stats.old_gen_0_objects, 0);
    EXPECT_EQ(stats.old_gen_1_objects, 0);
    EXPECT_EQ(stats.old_gen_2_objects, 0);

    // 验证根集初始状态
    auto root_stats = root_set_->get_stats();
    EXPECT_EQ(root_stats.total_roots, 0);
    EXPECT_EQ(root_stats.unique_objects, 0);
}

/**
 * 测试对象添加和基本管理功能
 * 验证对象能够正确添加到GC管理中
 */
TEST_F(GenerationalGCTest, BasicObjectManagement) {
    // 创建不同类型的对象
    auto str_obj = create_string("test_string");
    auto list_obj = create_list();
    auto dict_obj = create_dict();

    // 添加到GC管理
    gc_->add_object(str_obj.get());
    gc_->add_object(list_obj.get());
    gc_->add_object(dict_obj.get());

    // 验证对象被正确添加
    auto stats = gc_->get_stats();
    EXPECT_EQ(stats.total_objects, 3);
    EXPECT_EQ(stats.young_gen_objects, 3); // 新对象应该在年轻代

    // 验证对象的代信息（新对象应该从年轻代开始）
    EXPECT_EQ(str_obj->get_generation(), 0); // 年轻代
    EXPECT_EQ(list_obj->get_generation(), 0);
    EXPECT_EQ(dict_obj->get_generation(), 0);

    // 验证对象标记状态
    EXPECT_FALSE(str_obj->is_marked());
    EXPECT_FALSE(list_obj->is_marked());
    EXPECT_FALSE(dict_obj->is_marked());
}

/**
 * 测试根集合的基本操作
 * 验证根对象能够正确添加、删除和查询
 */
TEST_F(GenerationalGCTest, BasicRootSetOperations) {
    auto root_obj = create_string("root_object");

    // 测试添加根对象
    root_set_->add_root(root_obj.get(), GCRootSet::RootType::GLOBAL);
    EXPECT_EQ(root_set_->size(), 1);
    EXPECT_EQ(root_set_->unique_size(), 1);
    EXPECT_TRUE(root_set_->contains(root_obj.get()));

    // 测试根对象类型
    EXPECT_EQ(root_set_->get_root_type(root_obj.get()), GCRootSet::RootType::GLOBAL);
    EXPECT_EQ(root_set_->count_type(GCRootSet::RootType::GLOBAL), 1);

    // 测试修改根对象类型
    root_set_->set_root_type(root_obj.get(), GCRootSet::RootType::STACK);
    EXPECT_EQ(root_set_->get_root_type(root_obj.get()), GCRootSet::RootType::STACK);
    EXPECT_EQ(root_set_->count_type(GCRootSet::RootType::STACK), 1);
    EXPECT_EQ(root_set_->count_type(GCRootSet::RootType::GLOBAL), 0);

    // 测试移除根对象
    EXPECT_TRUE(root_set_->remove_root(root_obj.get()));
    EXPECT_EQ(root_set_->size(), 0);
    EXPECT_FALSE(root_set_->contains(root_obj.get()));

    // 测试重复移除
    EXPECT_FALSE(root_set_->remove_root(root_obj.get()));
}

/**
 * 测试批量操作
 * 验证根集的批量添加和删除功能
 */
TEST_F(GenerationalGCTest, BatchRootSetOperations) {
    std::vector<Object*> objects;

    // 创建多个对象
    for (int i = 0; i < 5; ++i) {
        auto obj = create_string("batch_object_" + std::to_string(i));
        objects.push_back(obj.get());
        test_objects_.push_back(std::move(obj));
    }

    // 批量添加根对象
    root_set_->add_roots(objects, GCRootSet::RootType::USER);
    EXPECT_EQ(root_set_->size(), 5);
    EXPECT_EQ(root_set_->count_type(GCRootSet::RootType::USER), 5);

    // 测试获取特定类型的根对象
    auto user_roots = root_set_->get_roots(GCRootSet::RootType::USER);
    EXPECT_EQ(user_roots.size(), 5);

    // 清空特定类型的根对象
    root_set_->clear_roots(GCRootSet::RootType::USER);
    EXPECT_EQ(root_set_->size(), 0);
    EXPECT_EQ(root_set_->count_type(GCRootSet::RootType::USER), 0);
}

/**
 * 测试基本的垃圾回收过程
 * 验证GC能够执行完整的标记-清除过程
 */
TEST_F(GenerationalGCTest, BasicCollectionProcess) {
    // 创建一些对象但不添加到根集
    create_objects(10);

    auto stats_before = gc_->get_stats();
    EXPECT_EQ(stats_before.total_objects, 10);

    // 执行垃圾回收（应该回收所有对象，因为没有根引用）
    auto collection_time = measure_time([&]() {
        auto result = gc_->collect();

        // 验证回收结果
        EXPECT_GT(result.objects_collected, 0);
        EXPECT_GT(result.collection_time_ms, 0.0);
        EXPECT_GT(result.young_gen_collected, 0);
    });

    // 验证回收后的统计信息
    auto stats_after = gc_->get_stats();
    EXPECT_EQ(stats_after.total_objects, 0); // 所有对象都应该被回收
    EXPECT_EQ(stats_after.total_collections, 1);
    EXPECT_GT(stats_after.total_bytes_freed, 0);
    EXPECT_GT(stats_after.average_collection_time_ms, 0.0);

    // 性能验证：回收时间应该在合理范围内
    EXPECT_LT(collection_time, 100.0); // 期望在100ms内完成
}

// ============================================================================
// 2. 分代机制测试
// ============================================================================

/**
 * 测试对象在分代中的分布
 * 验证新对象从年轻代开始
 */
TEST_F(GenerationalGCTest, GenerationalObjectDistribution) {
    // 创建对象并验证初始分布
    create_objects(20);

    auto stats = gc_->get_stats();
    EXPECT_EQ(stats.total_objects, 20);
    EXPECT_EQ(stats.young_gen_objects, 20);
    EXPECT_EQ(stats.old_gen_0_objects, 0);
    EXPECT_EQ(stats.old_gen_1_objects, 0);
    EXPECT_EQ(stats.old_gen_2_objects, 0);
}

/**
 * 测试对象晋升机制
 * 验证存活对象能够正确晋升到老年代
 */
TEST_F(GenerationalGCTest, ObjectPromotionMechanism) {
    // 创建对象并添加到根集（确保它们存活）
    std::vector<Object*> surviving_objects;
    for (int i = 0; i < 10; ++i) {
        auto obj = create_string("surviving_object_" + std::to_string(i));
        surviving_objects.push_back(obj.get());
        gc_->add_object(obj.get());
        root_set_->add_root(obj.get()); // 添加到根集确保存活
        test_objects_.push_back(std::move(obj));
    }

    // 创建一些临时对象（会被回收）
    create_objects(5);

    auto stats_before = gc_->get_stats();
    EXPECT_EQ(stats_before.total_objects, 15); // 10个存活 + 5个临时

    // 执行多次垃圾回收以触发晋升
    for (int i = 0; i < 5; ++i) {
        auto result = gc_->collect();

        // 验证每次回收都处理了一些对象
        if (i == 0) {
            // 第一次回收应该回收临时对象
            EXPECT_EQ(result.objects_collected, 5);
        }

        // 验证存活对象仍然存在
        for (auto* obj : surviving_objects) {
            EXPECT_TRUE(obj->is_valid_object());
        }
    }

    // 验证最终的对象分布
    auto stats_after = gc_->get_stats();
    EXPECT_EQ(stats_after.total_objects, 10); // 应该只剩10个存活对象

    // 验证至少有一些对象晋升到了老年代
    EXPECT_GT(stats_after.old_gen_0_objects + stats_after.old_gen_1_objects + stats_after.old_gen_2_objects, 0);
}

/**
 * 测试代际平衡机制
 * 验证GC能够平衡不同代之间的对象分布
 */
TEST_F(GenerationalGCTest, GenerationalBalance) {
    // 创建大量对象来触发平衡机制
    const size_t OBJECT_COUNT = 100;
    create_objects(OBJECT_COUNT);

    // 执行多次回收以观察代际分布
    for (int i = 0; i < 10; ++i) {
        gc_->collect();

        auto stats = gc_->get_stats();

        // 验证对象总数不超过创建的数量
        EXPECT_LE(stats.total_objects, OBJECT_COUNT);

        // 验证代际分布的合理性
        size_t total_gen_objects = stats.young_gen_objects +
                                  stats.old_gen_0_objects +
                                  stats.old_gen_1_objects +
                                  stats.old_gen_2_objects;
        EXPECT_EQ(total_gen_objects, stats.total_objects);
    }
}

// ============================================================================
// 3. 标记-清除算法测试
// ============================================================================

/**
 * 测试标记阶段
 * 验证从根对象开始的标记过程
 */
TEST_F(GenerationalGCTest, MarkingPhase) {
    create_object_graph(); // 创建复杂的对象图

    // 验证初始状态（所有对象都未被标记）
    for (const auto& obj : graph_objects_) {
        EXPECT_FALSE(obj->is_marked());
    }

    // 执行垃圾回收，这会触发标记阶段
    auto result = gc_->collect();

    // 验证根集中的对象被标记
    auto roots = root_set_->get_roots();
    for (auto* root : roots) {
        if (root) {
            // 注意：实际的标记状态可能因为GC实现而异
            // 这里主要验证GC过程能够正常完成
            EXPECT_TRUE(root->is_valid_object());
        }
    }

    // 验证回收结果
    EXPECT_GT(result.collection_time_ms, 0.0);
}

/**
 * 测试复杂对象图的可达性分析
 * 验证GC能够正确处理循环引用等复杂情况
 */
TEST_F(GenerationalGCTest, ComplexObjectGraphReachability) {
    // 创建循环引用的对象图
    auto list1 = create_list();
    auto list2 = create_list();
    auto dict = create_dict();

    // 建立循环引用（注意：这里简化了实际的Value构造）
    // 在真实实现中，需要正确处理Value的构造和引用

    gc_->add_object(list1.get());
    gc_->add_object(list2.get());
    gc_->add_object(dict.get());

    // 只将一个对象添加到根集
    root_set_->add_root(list1.get());

    // 执行回收
    auto result = gc_->collect();

    // 验证可达对象存活
    EXPECT_TRUE(list1->is_valid_object());

    // 验证回收过程正常完成
    EXPECT_GT(result.collection_time_ms, 0.0);
}

// ============================================================================
// 4. 增量垃圾回收测试
// ============================================================================

/**
 * 测试增量垃圾回收的基本功能
 * 验证增量回收能够分阶段执行
 */
TEST_F(GenerationalGCTest, BasicIncrementalCollection) {
    // 创建足够多的对象以确保需要增量处理
    const size_t LARGE_OBJECT_COUNT = 200;
    create_objects(LARGE_OBJECT_COUNT);

    auto stats_before = gc_->get_stats();
    EXPECT_EQ(stats_before.total_objects, LARGE_OBJECT_COUNT);

    // 执行增量回收
    auto incremental_result = gc_->incremental_collect();

    // 验证增量回收结果
    EXPECT_GE(incremental_result.collection_time_ms, 0.0);

    // 如果增量回收没有完成所有工作，继续执行
    while (gc_->needs_incremental_collection()) {
        auto result = gc_->incremental_collect();
        EXPECT_GE(result.collection_time_ms, 0.0);

        // 防止无限循环
        static int max_iterations = 10;
        if (--max_iterations <= 0) {
            break;
        }
    }

    // 验证最终状态
    auto stats_after = gc_->get_stats();
    EXPECT_LT(stats_after.total_objects, LARGE_OBJECT_COUNT);
}

/**
 * 测试增量回收的阶段管理
 * 验证增量回收能够正确地在不同阶段之间切换
 */
TEST_F(GenerationalGCTest, IncrementalPhaseManagement) {
    create_objects(50); // 创建适量的对象

    // 记录初始阶段
    auto initial_phase = gc_->get_incremental_phase();
    EXPECT_EQ(initial_phase, GarbageCollector::IncrementalPhase::IDLE);

    // 执行增量回收步骤
    auto result = gc_->incremental_collect();

    // 根据实现，阶段可能已经变化或保持在IDLE
    // 主要验证增量回收能够正常执行
    EXPECT_GE(result.collection_time_ms, 0.0);

    // 继续执行直到完成
    int iterations = 0;
    while (gc_->needs_incremental_collection() && iterations < 5) {
        gc_->incremental_collect();
        iterations++;
    }

    // 验证最终回到IDLE状态
    EXPECT_EQ(gc_->get_incremental_phase(), GarbageCollector::IncrementalPhase::IDLE);
}

// ============================================================================
// 5. 性能和统计测试
// ============================================================================

/**
 * 测试垃圾回收的性能特征
 * 验证GC能够在合理时间内处理大量对象
 */
TEST_F(GenerationalGCTest, PerformanceCharacteristics) {
    const size_t PERFORMANCE_TEST_OBJECTS = 1000;

    // 性能测试：创建大量对象
    double creation_time = measure_time([&]() {
        for (size_t i = 0; i < PERFORMANCE_TEST_OBJECTS; ++i) {
            auto obj = create_string("perf_test_" + std::to_string(i));
            gc_->add_object(obj.get());
            test_objects_.push_back(std::move(obj));
        }
    });

    auto stats_before = gc_->get_stats();
    EXPECT_EQ(stats_before.total_objects, PERFORMANCE_TEST_OBJECTS);

    // 性能测试：执行垃圾回收
    double collection_time = measure_time([&]() {
        auto result = gc_->collect();
        EXPECT_GT(result.objects_collected, 0);
    });

    // 性能验证
    EXPECT_LT(creation_time, 1000.0);  // 创建时间应在1秒内
    EXPECT_LT(collection_time, 500.0);  // 回收时间应在500ms内

    // 计算性能指标
    auto stats_after = gc_->get_stats();
    double objects_per_ms = static_cast<double>(PERFORMANCE_TEST_OBJECTS) / collection_time;

    // 性能应该满足基本要求（至少每毫秒处理几个对象）
    EXPECT_GT(objects_per_ms, 1.0);

    std::cout << "性能测试结果:" << std::endl;
    std::cout << "  创建对象数: " << PERFORMANCE_TEST_OBJECTS << std::endl;
    std::cout << "  创建时间: " << creation_time << "ms" << std::endl;
    std::cout << "  回收时间: " << collection_time << "ms" << std::endl;
    std::cout << "  处理速度: " << objects_per_ms << " 对象/毫秒" << std::endl;
}

/**
 * 测试内存使用和统计信息
 * 验证各种统计数据的准确性
 */
TEST_F(GenerationalGCTest, MemoryUsageAndStatistics) {
    // 创建不同类型的对象
    auto str_obj = create_string("statistics_test_string");
    auto list_obj = create_list({Value::make_number(1), Value::make_number(2), Value::make_number(3)});
    auto dict_obj = create_dict();

    dict_obj->set("key1", Value::make_number(42));
    dict_obj->set("key2", Value::string("test_value"));

    gc_->add_object(str_obj.get());
    gc_->add_object(list_obj.get());
    gc_->add_object(dict_obj.get());

    // 添加到根集
    root_set_->add_root(str_obj.get(), GCRootSet::RootType::GLOBAL);
    root_set_->add_root(list_obj.get(), GCRootSet::RootType::STACK);
    root_set_->add_root(dict_obj.get(), GCRootSet::RootType::REGISTER);

    // 验证GC统计信息
    auto gc_stats = gc_->get_stats();
    EXPECT_EQ(gc_stats.total_objects, 3);
    EXPECT_GT(gc_stats.total_bytes_allocated, 0);

    // 验证根集统计信息
    auto root_stats = root_set_->get_stats();
    EXPECT_EQ(root_stats.total_roots, 3);
    EXPECT_EQ(root_stats.unique_objects, 3);
    EXPECT_EQ(root_stats.global_roots, 1);
    EXPECT_EQ(root_stats.stack_roots, 1);
    EXPECT_EQ(root_stats.register_roots, 1);

    // 执行回收并验证统计更新
    auto result = gc_->collect();

    auto gc_stats_after = gc_->get_stats();
    EXPECT_EQ(gc_stats_after.total_collections, 1);
    EXPECT_GT(gc_stats_after.total_bytes_freed, 0);
    EXPECT_GT(gc_stats_after.average_collection_time_ms, 0.0);

    // 因为对象都在根集中，应该不会被回收
    EXPECT_EQ(gc_stats_after.total_objects, 3);
}

// ============================================================================
// 6. 边界条件和错误处理测试
// ============================================================================

/**
 * 测试空对象的垃圾回收
 * 验证GC能够正确处理空集合的情况
 */
TEST_F(GenerationalGCTest, EmptyCollectionHandling) {
    // 在没有任何对象的情况下执行回收
    auto result = gc_->collect();

    // 验证回收过程正常完成
    EXPECT_EQ(result.objects_collected, 0);
    EXPECT_EQ(result.young_gen_collected, 0);
    // CollectionResult不包含old_gen_0_objects字段，移除此检查
    EXPECT_GT(result.collection_time_ms, 0.0);

    auto stats = gc_->get_stats();
    EXPECT_EQ(stats.total_objects, 0);
    EXPECT_EQ(stats.total_collections, 1);
}

/**
 * 测试大量根对象的处理
 * 验证GC能够处理大量的根对象引用
 */
TEST_F(GenerationalGCTest, LargeRootSetHandling) {
    const size_t LARGE_ROOT_COUNT = 500;
    std::vector<Object*> root_objects;

    // 创建大量根对象
    for (size_t i = 0; i < LARGE_ROOT_COUNT; ++i) {
        auto obj = create_string("large_root_test_" + std::to_string(i));
        root_objects.push_back(obj.get());
        gc_->add_object(obj.get());
        root_set_->add_root(obj.get(), GCRootSet::RootType::USER);
        test_objects_.push_back(std::move(obj));
    }

    // 验证根集大小
    EXPECT_EQ(root_set_->size(), LARGE_ROOT_COUNT);
    EXPECT_EQ(root_set_->unique_size(), LARGE_ROOT_COUNT);

    // 执行回收（所有对象都应该存活，因为都在根集中）
    auto result = gc_->collect();

    // 验证所有对象都存活
    auto stats = gc_->get_stats();
    EXPECT_EQ(stats.total_objects, LARGE_ROOT_COUNT);
    EXPECT_EQ(result.objects_collected, 0); // 没有对象被回收

    // 验证根集统计
    auto root_stats = root_set_->get_stats();
    EXPECT_EQ(root_stats.total_roots, LARGE_ROOT_COUNT);
    EXPECT_EQ(root_stats.user_roots, LARGE_ROOT_COUNT);
}

/**
 * 测试GC启用/禁用功能
 * 验证GC能够正确响应启用/禁用控制
 */
TEST_F(GenerationalGCTest, EnableDisableFunctionality) {
    // 创建一些对象
    create_objects(10);

    // 禁用GC
    gc_->set_enabled(false);
    EXPECT_FALSE(gc_->is_enabled());

    // 执行回收（应该不执行任何操作）
    auto result_disabled = gc_->collect();
    EXPECT_EQ(result_disabled.objects_collected, 0);
    EXPECT_EQ(result_disabled.collection_time_ms, 0.0);

    auto stats_disabled = gc_->get_stats();
    EXPECT_EQ(stats_disabled.total_collections, 0); // 收集次数不应增加

    // 重新启用GC
    gc_->set_enabled(true);
    EXPECT_TRUE(gc_->is_enabled());

    // 执行回收（应该正常执行）
    auto result_enabled = gc_->collect();
    EXPECT_GT(result_enabled.objects_collected, 0);
    EXPECT_GT(result_enabled.collection_time_ms, 0.0);

    auto stats_enabled = gc_->get_stats();
    EXPECT_EQ(stats_enabled.total_collections, 1); // 收集次数应该增加
}

/**
 * 测试统计信息的重置功能
 * 验证统计信息能够正确重置
 */
TEST_F(GenerationalGCTest, StatisticsReset) {
    // 创建对象并执行回收以产生统计数据
    create_objects(5);
    gc_->collect();

    // 验证统计信息存在
    auto stats_before = gc_->get_stats();
    EXPECT_GT(stats_before.total_objects, 0);
    EXPECT_EQ(stats_before.total_collections, 1);
    EXPECT_GT(stats_before.total_bytes_allocated, 0);

    // 重置统计信息
    gc_->reset_stats();

    // 验证统计信息被重置
    auto stats_after = gc_->get_stats();
    EXPECT_EQ(stats_after.total_objects, 0);
    EXPECT_EQ(stats_after.total_collections, 0);
    EXPECT_EQ(stats_after.total_bytes_allocated, 0);
    EXPECT_EQ(stats_after.total_bytes_freed, 0);
    EXPECT_EQ(stats_after.average_collection_time_ms, 0.0);
}

// ============================================================================
// 7. 线程安全和并发测试
// ============================================================================

/**
 * 测试GCManager的全局实例管理
 * 验证全局GC管理器的单例特性
 */
TEST_F(GenerationalGCTest, GCManagerGlobalInstance) {
    // 设置全局根集
    GCManager::set_global_root_set(root_set_.get());

    // 获取多个实例引用
    auto& gc1 = GCManager::get_instance();
    auto& gc2 = GCManager::get_instance();

    // 验证是同一个实例
    EXPECT_EQ(&gc1, &gc2);

    // 测试全局操作
    GCManager::reset_global_stats();
    auto global_stats = GCManager::get_global_stats();
    EXPECT_EQ(global_stats.total_objects, 0);

    // 测试全局回收
    create_objects(5);
    auto global_result = GCManager::collect_garbage();
    EXPECT_GT(global_result.objects_collected, 0);
}

/**
 * 测试根集的线程安全特性
 * 验证根集操作在多线程环境下的安全性
 */
TEST_F(GenerationalGCTest, RootSetThreadSafety) {
    // 测试锁定机制
    EXPECT_FALSE(root_set_->is_locked());

    root_set_->lock();
    EXPECT_TRUE(root_set_->is_locked());

    root_set_->unlock();
    EXPECT_FALSE(root_set_->is_locked());

    // 测试根集完整性验证
    root_set_->validate_integrity();

    // 添加一些对象后再次验证
    auto obj = create_string("integrity_test");
    root_set_->add_root(obj.get());
    root_set_->validate_integrity();
}

// ============================================================================
// 8. 综合集成测试
// ============================================================================

/**
 * 综合测试：模拟真实使用场景
 * 验证GC在复杂场景下的综合表现
 */
TEST_F(GenerationalGCTest, ComprehensiveIntegrationTest) {
    // 模拟真实应用的使用模式

    // 1. 创建大量临时对象
    std::vector<std::unique_ptr<MockStringObject>> temp_objects;
    for (int i = 0; i < 100; ++i) {
        auto temp_obj = create_string("temp_" + std::to_string(i));
        gc_->add_object(temp_obj.get());
        temp_objects.push_back(std::move(temp_obj));
    }

    // 2. 创建一些长期存活的对象
    std::vector<Object*> persistent_objects;
    for (int i = 0; i < 10; ++i) {
        auto persistent_obj = create_string("persistent_" + std::to_string(i));
        persistent_objects.push_back(persistent_obj.get());
        gc_->add_object(persistent_obj.get());
        root_set_->add_root(persistent_obj.get()); // 确保存活
        test_objects_.push_back(std::move(persistent_obj));
    }

    auto stats_initial = gc_->get_stats();
    EXPECT_EQ(stats_initial.total_objects, 110); // 100临时 + 10持久

    // 3. 执行多次垃圾回收
    for (int cycle = 0; cycle < 5; ++cycle) {
        auto result = gc_->collect();

        // 验证持久对象仍然存活
        for (auto* obj : persistent_objects) {
            EXPECT_TRUE(obj->is_valid_object());
        }

        // 模拟应用工作：创建新对象，销毁旧对象
        if (cycle < 3) {
            temp_objects.clear(); // 销毁临时对象引用
        }
    }

    // 4. 验证最终状态
    auto stats_final = gc_->get_stats();

    // 应该只剩持久对象
    EXPECT_EQ(stats_final.total_objects, 10);

    // 验证持久对象的代信息（应该有一些晋升到老年代）
    bool has_promoted_objects = false;
    for (auto* obj : persistent_objects) {
        if (obj->get_generation() > 0) {
            has_promoted_objects = true;
            break;
        }
    }
    EXPECT_TRUE(has_promoted_objects);

    // 5. 性能验证
    EXPECT_GT(stats_final.total_collections, 0);
    EXPECT_GT(stats_final.average_collection_time_ms, 0.0);

    std::cout << "集成测试结果:" << std::endl;
    std::cout << "  总回收次数: " << stats_final.total_collections << std::endl;
    std::cout << "  平均回收时间: " << stats_final.average_collection_time_ms << "ms" << std::endl;
    std::cout << "  最终对象数: " << stats_final.total_objects << std::endl;
    std::cout << "  年轻代对象: " << stats_final.young_gen_objects << std::endl;
    std::cout << "  老年代对象: " << (stats_final.old_gen_0_objects +
                                     stats_final.old_gen_1_objects +
                                     stats_final.old_gen_2_objects) << std::endl;
}